// Package u2 提供并发控制相关功能，支持QPS限制、最大执行时间等控制。
//
// 该包主要用于控制并发任务的执行频率，防止系统过载。主要功能包括：
// - QPS（每秒查询数）限制
// - 最大执行时间控制
// - 并发任务管理
package u2

// import (
// 	"fmt"
// 	"time"
// )

// // ForConfig 定义并发控制配置。
// //
// // 该结构体用于配置并发控制的各种参数，包括QPS限制、最大执行时间等。
// type ForConfig struct {
// 	MaxRunSec       int       `json:"maxRunSec"`  // 最大执行时间（秒），0表示不限制
// 	LimitTimes      int       `json:"limitTimes"` // 总执行次数限制
// 	Max_QPS         int       `json:"max_QPS"`    // 最大QPS（每秒查询数）
// 	PrintQPS        bool      `json:"printQPS"`   // 是否打印QPS信息
// 	Debug           bool      `json:"debug"`      // 是否启用调试模式
// 	StartTime       time.Time // 任务开始时间
// 	secondBucket    chan bool // QPS控制通道
// 	tmpSecondBucket chan bool // 临时QPS控制通道
// 	bucketRun       chan bool // 运行控制通道
// 	runTimes        int       // 当前执行次数
// 	init            bool      // 是否已初始化
// 	uuid            string    // 唯一标识符
// 	stopChan        chan bool // 停止信号通道
// }

// // setSecondBucket 初始化并维护QPS控制通道。
// //
// // 该方法会启动一个goroutine来维护QPS控制，每秒补充令牌到secondBucket中。
// // 如果无法写入令牌，则会跳过当前迭代。
// func (f *ForConfig) setSecondBucket() {
// 	if f.bucketRun == nil {
// 		f.bucketRun = make(chan bool, 1)
// 	}
// 	if len(f.bucketRun) > 0 {
// 		return
// 	}

// 	select {
// 	case f.bucketRun <- true:
// 		f.StartTime = time.Now()
// 	case <-time.After(2 * time.Second):
// 		return
// 	}

// 	if f.Max_QPS <= 0 {
// 		f.Max_QPS = 100
// 	}
// 	if f.secondBucket == nil {
// 		f.secondBucket = make(chan bool, f.Max_QPS)
// 	}

// 	ticker := time.NewTicker(time.Second)
// 	defer ticker.Stop()

// 	for {
// 		select {
// 		case <-ticker.C:
// 			runNum := f.Max_QPS - len(f.secondBucket)
// 			if f.PrintQPS {
// 				fmt.Printf("uuid: %s, QPS: %d, max_QPS: %d, runAllNum: %d, remain: %d, runtime: %s\n",
// 					f.uuid, runNum, f.Max_QPS, f.runTimes, len(f.secondBucket), time.Since(f.StartTime).String())
// 			}
// 			for i := 0; i < runNum; i++ {
// 				select {
// 				case f.secondBucket <- true:
// 				default:
// 					// 如果无法写入，直接跳过
// 					continue
// 				}
// 			}
// 		case <-f.stopChan:
// 			return
// 		}
// 	}
// }

// // WithOutQPS 不消耗QPS执行任务。
// //
// // 该方法允许任务在不消耗QPS的情况下执行。
// func (f *ForConfig) WithOutQPS() {
// 	if f.tmpSecondBucket != nil {
// 		f.tmpSecondBucket <- true
// 	}
// }

// // Skip 跳过计数返回。
// //
// // 该方法用于跳过当前任务的计数，并返回true。
// func (f *ForConfig) Skip() bool {
// 	if f.tmpSecondBucket != nil {
// 		f.tmpSecondBucket <- true
// 	}
// 	return true
// }

// // initData 初始化配置数据。
// //
// // 该方法用于初始化ForConfig的各个字段，确保配置正确。
// func (config *ForConfig) initData() {
// 	if !config.init {
// 		if config == nil {
// 			config = &ForConfig{}
// 		}
// 		if config.Max_QPS <= 0 {
// 			config.Max_QPS = 100
// 		}
// 		if config.bucketRun == nil {
// 			config.bucketRun = make(chan bool, 1)
// 		}
// 		if config.secondBucket == nil {
// 			config.secondBucket = make(chan bool, config.Max_QPS)
// 		}
// 		if config.tmpSecondBucket == nil {
// 			config.tmpSecondBucket = make(chan bool, config.Max_QPS*10)
// 		}
// 		config.uuid = UUID()
// 		config.stopChan = make(chan bool)
// 		go config.setSecondBucket()
// 		config.init = true
// 	}
// }

// // For 创建并初始化ForConfig实例。
// //
// // 参数:
// //   - config: 配置实例，如果为nil则会创建新的实例
// //
// // 返回值:
// //   - *ForConfig: 初始化后的ForConfig实例
// func For(config *ForConfig) *ForConfig {
// 	if config == nil {
// 		config = &ForConfig{}
// 	}
// 	config.initData()
// 	return config
// }

// // getBucketKey 获取执行令牌。
// //
// // 该方法用于从secondBucket中获取执行令牌，如果无法获取则会等待。
// //
// // 参数:
// //   - f: ForConfig实例
// //   - stop: 停止信号通道
// //   - run: 运行控制通道
// //
// // 返回值:
// //   - bool: 是否成功获取令牌
// func getBucketKey(f *ForConfig, stop chan bool, run chan bool) bool {
// 	for {
// 		select {
// 		case <-f.secondBucket:
// 			f.runTimes++
// 			if f.MaxRunSec > 0 && time.Since(f.StartTime).Seconds() > float64(f.MaxRunSec) {
// 				if len(stop) == 0 {
// 					stop <- true
// 				}
// 				if f.Debug {
// 					fmt.Println("stop by MaxRunSec")
// 				}
// 				return false
// 			}
// 			select {
// 			case run <- true:
// 				return true
// 			case <-time.After(2 * time.Second):
// 				continue
// 			}
// 		case <-f.tmpSecondBucket:
// 			return true
// 		case <-time.After(2 * time.Second):
// 			if f.runTimes > f.LimitTimes {
// 				if len(stop) == 0 {
// 					stop <- true
// 				}
// 				if f.Debug {
// 					fmt.Println("stop by LimitTimes 2")
// 				}
// 				return false
// 			}
// 			if f.MaxRunSec > 0 && time.Since(f.StartTime).Seconds() > float64(f.MaxRunSec) {
// 				if len(stop) == 0 {
// 					stop <- true
// 				}
// 				if f.Debug {
// 					fmt.Println("stop by MaxRunSec 2")
// 				}
// 				return false
// 			}
// 			continue
// 		case <-stop:
// 			if f.Debug {
// 				fmt.Println("stop by stop")
// 			}
// 			return false
// 		}
// 	}
// }

// // Slice 并发处理切片中的每个元素。
// //
// // 参数:
// //   - list: 要处理的切片
// //   - runNum: 最大并发数
// //   - f: 处理函数，返回false表示停止处理
// //
// // 返回值:
// //   - bool: 是否成功完成所有处理
// func (fo *ForConfig) Slice(list interface{}, runNum int, f func(i int, v interface{}) bool) bool {
// 	if !fo.init {
// 		fo.initData()
// 	}
// 	if runNum <= 0 {
// 		runNum = 1
// 	}

// 	ch := make(chan bool, runNum)
// 	lists := Interface2InterfaceSlice(list)
// 	stop := make(chan bool, 1)

// 	for ind, v := range lists {
// 		if !getBucketKey(fo, stop, ch) {
// 			return len(stop) <= 0
// 		}
// 		if fo.LimitTimes > 0 && fo.runTimes > fo.LimitTimes {
// 			break
// 		}

// 		go func(ind int, v interface{}) {
// 			defer func() {
// 				if r := recover(); r != nil {
// 					stop <- true
// 				}
// 			}()

// 			if !f(ind, v) {
// 				stop <- true
// 			} else {
// 				<-ch
// 				if fo.LimitTimes > 0 && fo.runTimes >= fo.LimitTimes {
// 					if len(stop) == 0 {
// 						stop <- true
// 					}
// 					if fo.Debug {
// 						fmt.Println("stop by LimitTimes")
// 					}
// 				}
// 			}
// 		}(ind, v)
// 	}

// 	ticker := time.NewTicker(2 * time.Second)
// 	defer ticker.Stop()

// 	for range ticker.C {
// 		if len(ch) == 0 {
// 			return true
// 		}
// 		if len(stop) > 0 {
// 			return false
// 		}
// 	}
// 	return false
// }

// // Num 并发处理数字范围。
// //
// // 参数:
// //   - startNum: 起始数字
// //   - endNum: 结束数字
// //   - runNum: 最大并发数
// //   - f: 处理函数，返回false表示停止处理
// //
// // 返回值:
// //   - bool: 是否成功完成所有处理
// func (fo *ForConfig) Num(startNum, endNum, runNum int, f func(int) bool) bool {
// 	tmpSlice := make([]interface{}, 0)
// 	for i := startNum; i <= endNum; i++ {
// 		tmpSlice = append(tmpSlice, i)
// 	}
// 	return fo.Slice(tmpSlice, runNum, func(i int, ine interface{}) bool {
// 		if intf, ok := ine.(int); ok {
// 			return f(intf)
// 		} else {
// 			fmt.Println("error: trans:", ine)
// 			return false
// 		}
// 	})
// }

// // ForWithNum 并发处理数字范围。
// //
// // 参数:
// //   - startNum: 起始数字
// //   - endNum: 结束数字
// //   - runningNum: 最大并发数
// //   - f: 处理函数，返回false表示停止处理
// //
// // 返回值:
// //   - bool: 是否成功完成所有处理
// func ForWithNum(startNum, endNum, runningNum int, f func(int) bool) bool {
// 	tmpSlice := make([]interface{}, 0)
// 	for i := startNum; i <= endNum; i++ {
// 		tmpSlice = append(tmpSlice, i)
// 	}
// 	return ForSlice(tmpSlice, runningNum, func(_ int, ine interface{}) bool {
// 		intf, ok := ine.(int)
// 		if !ok {
// 			fmt.Println("error: invalid type conversion:", ine)
// 			return false
// 		}
// 		return f(intf)
// 	})
// }

// // ForSliceWithQPS 带QPS限制的并发处理。
// //
// // 参数:
// //   - list: 要处理的切片
// //   - runningNum: 最大并发数
// //   - Max_QPS: 最大QPS限制
// //   - f: 处理函数，返回false表示停止处理
// //
// // 返回值:
// //   - bool: 是否成功完成所有处理
// func ForSliceWithQPS(list interface{}, runningNum int, Max_QPS int, f func(int, interface{}) bool) bool {
// 	config := &ForConfig{Max_QPS: Max_QPS, PrintQPS: false}
// 	return config.Slice(list, runningNum, f)
// }

// // ForSlice 并发处理切片。
// //
// // 参数:
// //   - list: 要处理的切片
// //   - runningNum: 最大并发数
// //   - f: 处理函数，返回false表示停止处理
// //
// // 返回值:
// //   - bool: 是否成功完成所有处理
// func ForSlice(list interface{}, runningNum int, f func(int, interface{}) bool) bool {
// 	config := &ForConfig{Max_QPS: 10000, PrintQPS: false}
// 	return config.Slice(list, runningNum, f)
// }
